package cn.sccl.common.service;

import cn.sccl.common.model.PageResult;
import cn.sccl.common.dao.impl.BaseQuery;

import java.util.List;
import java.util.Map;

/**
 * Created by 杨浩宇 on 2016-02-22.
 */
public interface BaseManager<T> {

    /**
     * 根据ID获取对象
     *
     * @param id
     * @return
     */
    public T get(String id);

    /**
     * 根据ID获取一批对象
     *
     * @param ids
     * @return
     */
    public List<T> gets(List<String> ids);


    /**
     * 创建一个新对象
     *
     * @param model
     */
    public void create(T model);


    /**
     * 更新一个对象，全字段更新，并在事务提交时更新缓存
     *
     * @param model
     */
    public void update(T model);


    /**
     * 更新一个对象，用户决定是否需要立即更新缓存
     *
     * @param model
     * @param isupdateMC
     */
    public void update(T model, boolean isupdateMC);


    /**
     * 保存一个对象，如果对象ID为空，则会执行insert操作，否则执行全字段的update操作，并在事务提交时更新缓存
     *
     * @param model
     */
    public void save(T model);


    /**
     * 保存一个对象，如果对象ID为空，则会执行insert操作，否则执行全字段的update操作，用户决定是否需要立即更新缓存
     *
     * @param model
     * @param isupdateMC
     */
    public void save(T model, boolean isupdateMC);


    /**
     * 获取所有对象
     *
     * @return
     */
    public List<T> listAll();


    @Deprecated
    public List<T> query(BaseQuery query);


    /**
     * 根据ID删除一个对象
     *
     * @param id
     */
    public void delete(String id);


    /**
     * 删除一个对象
     * @param model
     */
//    public void delete(T model);

    /**
     * 批量删除
     *
     * @param list
     */
    public void deleteBatch(List<T> list);

    /**
     * 根据ID批量删除
     *
     * @param idArr
     */
    public void deleteBatch(String[] idArr);

    /**
     * 采用恒等的方式查询对象，即所有的where条件都采用 xx = yy的方式
     *
     * @param map
     * @return
     */
    public List<T> findBy(Map<String, Object> map);

    /**
     * 字符串模糊查询，即针对字符串形式的属性，where条件采用like的形式，其余条件采用xx=yy的形式
     *
     * @param map
     * @return
     */
    public List<T> findByLike(Map<String, Object> map);


    /**
     * 根据条件查询单个对象
     *
     * @param map
     * @return
     */
    public abstract T findUniqueBy(Map<String, Object> map);

    /**
     * @Title: updatePartialModel
     * @Description: 更新部分字段
     * @Return: void
     * @Throws:
     * @Author: bieby
     * @Date: 2013-11-9
     */
    public void updatePartialModel(T objModel);

    /**
     * @param o             需要保存的对象
     * @param aryNullFields 需要保持为null值的属性数组
     * @Title: updatePartialModel
     * @Description: 更新部分字段
     * @Return: void
     * @Throws:
     * @Author: zhouxinxi
     * @Date: 2013-12-21
     */
    public abstract void updatePartialModel(T o, String[] aryNullFields);

    /**
     * @param key T中某个属性
     * @param map 查询条件
     * @return
     * @Title: findMapBy
     * @Description: 查询结果缓存map
     * @Return: Map<String,T>
     * @Throws:
     * @Author: bieby
     * @Date: 2013-11-23
     */
    public Map<String, T> findMapBy(String key, Map<String, Object> map);

    /**
     * @param key T中某个属性
     * @param map 查询条件
     * @return
     * @Title: findMapByLike
     * @Description: 查询结果缓存map
     * @Return: Map<String,T>
     * @Throws:
     * @Author: bieby
     * @Date: 2013-11-23
     */
    public Map<String, T> findMapByLike(String key, Map<String, Object> map);

    /**
     * @param modelList
     * @Title: saveBatch
     * @Description: 全字段批量保存。
     * @Return: void
     * @Throws:
     * @Author: bieby
     * @Date: 2013-12-2
     */
    public void saveBatch(List<T> modelList);

    /**
     * @param modelList
     * @param isupdateMC 是否需要同步缓存：(true:同步缓存；false:删除缓存）
     * @Title: saveBatch
     * @Description: 全字段批量保存。
     * @Return: void
     * @Throws:
     * @Author: bieby
     * @Date: 2013-12-2
     */
    public void saveBatch(List<T> modelList, boolean isupdateMC);

    /**
     * @Title: savePartialBatch
     * @Description: 部分字段批量批量保存
     * @Return: void
     * @Throws:
     * @Author: bieby
     * @Date: 2013-12-3
     */
    public void savePartialBatch(List<T> modelList);

    /**
     * @param modelList
     * @param isupdateMC 是否需要同步缓存：(true:同步缓存；false:删除缓存）
     * @Title: savePartialBatch
     * @Description: 部分字段批量批量保存
     * @Return: void
     * @Throws:
     * @Author: bieby
     * @Date: 2013-12-3
     */
    public void savePartialBatch(List<T> modelList, boolean isupdateMC);

    /**
     * 分页查询，所有条件要求满足完全匹配，即where语句不会应用like条件
     *
     * @param pageIndex 页码
     * @param pageSize  分页大小
     * @param params
     * @return
     */
    public PageResult<T> pageQuery(long pageIndex, int pageSize, Map<String, Object> params);

    /**
     * 分页查询，字符串属性在where语句应用like条件
     *
     * @param pageIndex 页码
     * @param pageSize  分页大小
     * @param params
     * @return
     */
    public PageResult<T> pageQueryByLike(long pageIndex, int pageSize, Map<String, Object> params);
}
